import { StatusCodes } from 'http-status-codes';
import BaseController from './BaseController.js';
import db from '../models/index.js';
import { AppError } from '../middlewares/error.js';

const { User } = db;

class UserController extends BaseController {
  constructor() {
    super();
  }

  /**
   * 获取所有用户（管理员）
   */
  async getAllUsers(req, res, next) {
    try {
      // 只有管理员可以查看所有用户
      if (req.user.role !== User.ROLES.ADMIN) {
        return next(
          new AppError('您没有执行此操作的权限', StatusCodes.FORBIDDEN)
        );
      }

      const { page = 1, limit = 10, role, isActive } = req.query;
      const where = {};

      // 过滤条件
      if (role) where.role = role;
      if (isActive !== undefined) where.isActive = isActive === 'true';

      const result = await User.findAndCountAll({
        where,
        attributes: { exclude: ['password'] },
        offset: (page - 1) * limit,
        limit: parseInt(limit, 10),
        order: [['createdAt', 'DESC']],
      });

      res.status(StatusCodes.OK).json({
        success: true,
        message: '获取成功',
        data: {
          total: result.count,
          page: parseInt(page, 10),
          limit: parseInt(limit, 10),
          data: result.rows,
        }
      });
    } catch (error) {
      console.error('获取用户列表失败:', error);
      res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
        success: false,
        message: '获取用户列表失败',
        error: error.message
      });
    }
  }

  /**
   * 获取单个用户信息
   */
  async getUser(req, res, next) {
    try {
      const { id } = req.params;
      
      // 用户只能查看自己的信息，除非是管理员
      if (req.user.id !== parseInt(id, 10) && req.user.role !== User.ROLES.ADMIN) {
        return next(
          new AppError('您没有权限查看此用户信息', StatusCodes.FORBIDDEN)
        );
      }

      const user = await User.findByPk(id, {
        attributes: { exclude: ['password'] },
      });

      if (!user) {
        return next(
          new AppError('未找到该用户', StatusCodes.NOT_FOUND)
        );
      }

      this.success(res, user, '获取成功');
    } catch (error) {
      this.error(res, '获取用户信息失败', StatusCodes.INTERNAL_SERVER_ERROR, error);
    }
  }

  /**
   * 更新用户信息
   */
  async updateUser(req, res, next) {
    try {
      const { id } = req.params;
      
      // 用户只能更新自己的信息，除非是管理员
      if (req.user.id !== parseInt(id, 10) && req.user.role !== User.ROLES.ADMIN) {
        return next(
          new AppError('您没有权限更新此用户信息', StatusCodes.FORBIDDEN)
        );
      }

      // 不允许更新密码（使用专门的更新密码接口）
      if (req.body.password) {
        return next(
          new AppError('请使用 /update-password 接口更新密码', StatusCodes.BAD_REQUEST)
        );
      }

      // 不允许普通用户修改角色
      if (req.body.role && req.user.role !== User.ROLES.ADMIN) {
        return next(
          new AppError('您没有权限修改用户角色', StatusCodes.FORBIDDEN)
        );
      }

      const allowedFields = ['name', 'email', 'phone'];
      const updateData = {};

      // 过滤允许更新的字段
      Object.keys(req.body).forEach(key => {
        if (allowedFields.includes(key)) {
          updateData[key] = req.body[key];
        }
      });

      // 管理员可以更新更多字段
      if (req.user.role === User.ROLES.ADMIN) {
        if (req.body.role) updateData.role = req.body.role;
        if (req.body.isActive !== undefined) updateData.isActive = req.body.isActive;
      }

      const user = await User.findByPk(id);
      
      if (!user) {
        return next(
          new AppError('未找到该用户', StatusCodes.NOT_FOUND)
        );
      }

      const updatedUser = await user.update(updateData);
      
      // 移除密码字段
      updatedUser.password = undefined;
      
      this.success(res, updatedUser, '更新成功');
    } catch (error) {
      this.error(res, '更新用户信息失败', StatusCodes.INTERNAL_SERVER_ERROR, error);
    }
  }

  /**
   * 删除用户（软删除）
   */
  async deleteUser(req, res, next) {
    try {
      const { id } = req.params;
      
      // 只有管理员可以删除用户
      if (req.user.role !== User.ROLES.ADMIN) {
        return next(
          new AppError('您没有权限删除用户', StatusCodes.FORBIDDEN)
        );
      }

      // 不能删除自己
      if (req.user.id === parseInt(id, 10)) {
        return next(
          new AppError('不能删除自己的账户', StatusCodes.FORBIDDEN)
        );
      }

      const user = await User.findByPk(id);
      
      if (!user) {
        return next(
          new AppError('未找到该用户', StatusCodes.NOT_FOUND)
        );
      }

      // 软删除用户
      await user.update({ isActive: false });
      
      this.success(res, null, '用户已禁用');
    } catch (error) {
      this.error(res, '删除用户失败', StatusCodes.INTERNAL_SERVER_ERROR, error);
    }
  }

  /**
   * 获取当前用户的个人资料
   */
  getProfile(req, res) {
    // req.user 由 protect 中间件添加
    const user = req.user.toJSON();
    delete user.password; // 确保不返回密码
    this.success(res, user, '获取成功');
  }

  /**
   * 更新当前用户的个人资料
   */
  async updateProfile(req, res, next) {
    try {
      const { name, email, phone } = req.body;
      
      // 过滤允许更新的字段
      const updateData = {};
      if (name) updateData.name = name;
      if (email) updateData.email = email;
      if (phone !== undefined) updateData.phone = phone;

      const updatedUser = await req.user.update(updateData);
      
      // 移除密码字段
      updatedUser.password = undefined;
      
      this.success(res, updatedUser, '个人资料更新成功');
    } catch (error) {
      this.error(res, '更新个人资料失败', StatusCodes.INTERNAL_SERVER_ERROR, error);
    }
  }
}

export default new UserController();
